Computer programs are generally written in a high-level programming language (e.g., Java or C). Compilers are then used to translate the instructions of the high-level programming language into machine instructions that can be executed by a computer. The compilation process is generally divided into six phases:
1. Lexical analysis
2. Syntactic analysis
3. Semantic analysis
4. Intermediate code generation
5. Code optimization
6. Final code generation
During lexical analysis, the source code of the computer program is scanned and components or tokens of the high-level language are identified. The compiler then converts the source code into a series of tokens that can be processed during syntactic analysis. For example, during lexical analysis, the compiler would identify the statement
cTable=1.0;
as the variable (cTable), the operator(=), the constant (1.0), and a semicolon. A variable, operator, constant, and semicolon are tokens of the high-level language.
During syntactic analysis (also referred to as “parsing”), the compiler processes the tokens and generates a syntax tree to represent the program based on the syntax (also referred to as “grammar”) of the programming language. A syntax tree is a tree structure in which operators are represented by non-leaf nodes and their operands are represented by child nodes. In the above example, the operator (=) has two operands: the variable (cTable) and the constant (1.0). The terms “parse tree” and “syntax tree” are used interchangeably in this description to refer to the syntax-based tree generated as a result of syntactic analysis. For example, such a tree optionally may describe the derivation of the syntactic structure of the computer program (e.g., it may describe that a certain token is an identifier, which is an expression as defined by the syntax). Syntax-based trees may also be referred to as “concrete syntax trees” when the derivation of the syntactic structure is included, and as “abstract syntax trees” when the derivation is not included.
During semantic analysis, the compiler modifies the syntax tree to ensure semantic correctness. For example, if the variable (cTable) is an integer and the constant (1.0) is a floating-point, then during semantic analysis a floating point to integer conversion would be added to the syntax tree.
During intermediate code generation, code optimization, and final code generation, the compiler generates machine instructions to implement the program represented by the syntax tree. A computer can then execute the machine instructions.
A system has been described for generating and maintaining a computer program represented as an intentional program tree, which is a type of syntax tree. (For example, U.S. Pat. No. 5,790,863 entitled “Method and System for Generating and Displaying a Computer Program” and U.S. Pat. No. 6,097,888 entitled “Method and System for Reducing an Intentional Program Tree Represented by High-Level Computational Constructs,” both of which are hereby incorporated by reference.) The system provides a mechanism for directly manipulating nodes corresponding to “program elements” by adding, deleting, and moving the nodes within an intentional program tree. An intentional program tree is one type of “program tree.” A “program tree” is a tree representation of a computer program that includes operator nodes and operand nodes representing program elements. A program tree may also include inter-node references (i.e., graph structures linking nodes in the tree), such as a reference from a declaration node of an identifier to the node that defines that identifier's program element type. An abstract syntax tree and a concrete syntax tree are examples of a program tree. Once a program tree is generated, the system performs the steps of semantic analysis, intermediate code generation, code optimization, and final code generation to the transformation of the computer program represented by the program tree into executable code.
FIG. 1 is a diagram illustrating a portion of a program tree corresponding to the definition of a method. The method is defined by the following:
public static int increment (int i){i++; return i;}
Node 101 corresponds to the root of the sub-tree of the program tree representing the “increment” method. Nodes 102-108 are child nodes of the root node. Nodes 109 and 110 are child nodes of node 106, node 111 is a child node of node 107, and node 112 is a child node of node 108. Each node has a reference to another node in the program tree that defines the node type. For example, node 107 references a declaration node that defines a “statement,” and node 111 references (indicated by the dashed line) node 106 for the parameter “i.” Such referenced nodes are also referred to as declaration definitions.
Various editing facilities provide a “context-sensitive help” capability for a computer program. The information used to provide the help may be associated with the nodes of a program tree as comments, remarks, summaries, help information, to-do items, or other documentation. Such documentation may be stored as an attribute of a node. A programmer may specify such documentation for various nodes of a program tree during program development. When a programmer selects a node, an editing facility may display a list of help topics that are appropriate for the selected node (i.e., the editing facility is context-sensitive). For example, if the selected node represents a Java method call, then the editing facility may display an indication of programmer-specified remarks and an indication of system-defined documentation for a Java method call as help topics. The programmer-specified remarks may describe why the Java method is being called, and the system-defined remarks may describe the syntax and semantics of a Java method call semantics. When the programmer selects a help topic, the editing facility displays the associated documentation.
Although the editing facilities provide context-sensitive help, the help information may not include all the information that a programmer may need. For example, the help information associated with Java method call type may describe the details of the Java syntax of a method call. A programmer may, however, need more general information, such as what is an object-oriented method call or what is a function call. It would be desirable to have a help system that would provide more flexibility in selecting the desired level of detail of help information that is provided.